home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume2 / remote < prev    next >
Encoding:
Internet Message Format  |  1986-11-30  |  27.1 KB
  1. From: Arnold Robbins <gatech!arnold>
  2. Subject: Remote mag tape routines
  3. Keywords: remote magnetic tapes, tar, dd
  4. Newsgroups: mod.sources
  5. Approved: john@genrad.UUCP
  6.  
  7. Mod.sources:  Volume 2, Issue 21
  8. Submitted by: Arnold Robbins <gatech!arnold>
  9. Title: Remote mag tape routines, re-written as a general library (+ tar, dd)
  10.  
  11.  
  12. Although the remote mag tape stuff for tar was just posted recently, this
  13. is worth re-posting since it 1) fixes a few bugs, and 2) provides a much more
  14. general facility for accessing remote tape drives.  E.g., to fix dd for
  15. remote tape drives, all I had to do was add one line and recompile with
  16. the library.
  17.  
  18. Credit is given in the man page for the people who did the work.
  19.  
  20. Enjoy,
  21.  
  22. Arnold Robbins
  23. CSNET:    arnold@gatech    ARPA:    arnold%gatech.csnet@csnet-relay.arpa
  24. UUCP:    { akgua, allegra, hplabs, ihnp4, seismo, ut-sally }!gatech!arnold
  25. --------------------- axe your screen here -----------------------
  26. #!/bin/sh
  27. # This is a shell archive, meaning:
  28. # 1. Remove everything above the #!/bin/sh line.
  29. # 2. Save the resulting text in a file.
  30. # 3. Execute the file with /bin/sh (not csh) to create the files:
  31. #    README
  32. #    dd.1.DIFF
  33. #    dd.c.DIFF
  34. #    rmt.h
  35. #    rmtlib.c
  36. #    rmtops.3
  37. #    tar.1.DIFF
  38. #    tar.c.DIFF
  39. # This archive created: Mon Jul 29 13:04:33 1985
  40. # By:    Arnold Robbins (Pr1mebusters!)
  41. export PATH; PATH=/bin:$PATH
  42. echo shar: extracting "'README'" '(851 characters)'
  43. if test -f 'README'
  44. then
  45.     echo shar: over-writing existing file "'README'"
  46. fi
  47. cat << \SHAR_EOF > 'README'
  48. README  --- remote mag tape library and diffs for tar(1) and dd(1)
  49.  
  50. The files in this directory implement a library of routines which allow
  51. a user using the Unix system calls for i/o to transparently access a tape
  52. drive on a remote machine, via rsh(1) and rmt(8).
  53.  
  54. The files are as follows:
  55.  
  56. README        ---    This file.
  57. dd.1.DIFF    ---    Context diff for dd(1) man page.
  58. dd.c.DIFF    ---    Context diff for dd.c source code.
  59. tar.1.DIFF    ---    Context diff for tar(1) man page.
  60. tar.c.DIFF    ---    Context diff for tar.c source code.
  61. rmt.h        ---    Remote mag tape include file.
  62. rmtlib.c    ---    Remote mag tape library source code.
  63. rmtops.3    ---    Remote mag tape library man page.
  64.  
  65. The diffs are for BRL Unix 3.0 (4.2 BSD), your line numbers may vary.
  66. The tar(1) diffs include a fix to keep tar from damaging the file system;
  67. existing directories are removed only if they are empty.
  68. SHAR_EOF
  69. echo shar: extracting "'dd.1.DIFF'" '(1273 characters)'
  70. if test -f 'dd.1.DIFF'
  71. then
  72.     echo shar: over-writing existing file "'dd.1.DIFF'"
  73. fi
  74. cat << \SHAR_EOF > 'dd.1.DIFF'
  75. *** /usr/man/man1/dd.1    Mon Apr  4 06:12:26 1983
  76. --- dd.1    Wed Jul 24 12:29:58 1985
  77. ***************
  78. *** 23,29
  79.   .ns
  80.   .TP 
  81.   if=
  82. ! input file name; standard input is default
  83.   .br
  84.   .ns
  85.   .TP 
  86.  
  87. --- 23,45 -----
  88.   .ns
  89.   .TP 
  90.   if=
  91. ! input file name; standard input is default.
  92. ! If the input file name has the form
  93. ! .IR system [. user ]:/dev/???,
  94. ! then
  95. ! .I dd
  96. ! will attempt to use the tape drive /dev/??? on the remote system
  97. ! .IR system ,
  98. ! via
  99. ! .IR rsh (1),
  100. ! and
  101. ! .IR rmt (8).
  102. ! The optional
  103. ! .I user
  104. ! specifies the login name to use on the remote system.
  105. ! If it is not given, the current user's login name will be used.
  106. ! In all cases, the user must have the appropriate
  107. ! access permissions on the remote machine in order for this to work.
  108.   .br
  109.   .ns
  110.   .TP 
  111. ***************
  112. *** 28,34
  113.   .ns
  114.   .TP 
  115.   of=
  116. ! output file name; standard output is default
  117.   .br
  118.   .ns
  119.   .TP 
  120.  
  121. --- 44,51 -----
  122.   .ns
  123.   .TP 
  124.   of=
  125. ! output file name; standard output is default,
  126. ! remote file names may be used here as well.
  127.   .br
  128.   .ns
  129.   .TP 
  130. ***************
  131. *** 203,205
  132.   raw disks with bad sectors to insure 
  133.   .I dd
  134.   stays synchronized.
  135.  
  136. --- 220,224 -----
  137.   raw disks with bad sectors to insure 
  138.   .I dd
  139.   stays synchronized.
  140. + .br
  141. + Using a remote system's tape drive can be slow.
  142. SHAR_EOF
  143. echo shar: extracting "'dd.c.DIFF'" '(360 characters)'
  144. if test -f 'dd.c.DIFF'
  145. then
  146.     echo shar: over-writing existing file "'dd.c.DIFF'"
  147. fi
  148. cat << \SHAR_EOF > 'dd.c.DIFF'
  149. *** /usr/src/bin/dd.c    Fri Apr 29 04:20:35 1983
  150. --- dd.c    Tue Jul 23 14:13:53 1985
  151. ***************
  152. *** 2,7
  153.   #include <stdio.h>
  154.   #include <signal.h>
  155.   
  156.   #define    BIG    2147483647
  157.   #define    LCASE    01
  158.   #define    UCASE    02
  159.  
  160. --- 2,9 -----
  161.   #include <stdio.h>
  162.   #include <signal.h>
  163.   
  164. + #include <rmt.h>
  165. + 
  166.   #define    BIG    2147483647
  167.   #define    LCASE    01
  168.   #define    UCASE    02
  169. SHAR_EOF
  170. echo shar: extracting "'rmt.h'" '(904 characters)'
  171. if test -f 'rmt.h'
  172. then
  173.     echo shar: over-writing existing file "'rmt.h'"
  174. fi
  175. cat << \SHAR_EOF > 'rmt.h'
  176. /*
  177.  *    rmt.h
  178.  *
  179.  *    Added routines to replace open(), close(), lseek(), ioctl(), etc.
  180.  *    The preprocessor can be used to remap these the rmtopen(), etc
  181.  *    thus minimizing source changes.
  182.  *
  183.  *    This file must be included before <sys/stat.h>, since it redefines
  184.  *    stat to be rmtstat, so that struct stat xyzzy; declarations work
  185.  *    properly.
  186.  *
  187.  *    -- Fred Fish (w/some changes by Arnold Robbins)
  188.  */
  189.  
  190.  
  191. #ifndef access        /* avoid multiple redefinition */
  192. #ifndef lint        /* in this case what lint doesn't know won't hurt it */
  193. #define access rmtaccess
  194. #define close rmtclose
  195. #define creat rmtcreat
  196. #define dup rmtdup
  197. #define fcntl rmtfcntl
  198. #define fstat rmtfstat
  199. #define ioctl rmtioctl
  200. #define isatty rmtisatty
  201. #define lseek rmtlseek
  202. #define lstat rmtlstat
  203. #define open rmtopen
  204. #define read rmtread
  205. #define stat rmtstat
  206. #define write rmtwrite
  207.  
  208. extern long rmtlseek ();    /* all the rest are int's */
  209. #endif
  210. #endif
  211. SHAR_EOF
  212. echo shar: extracting "'rmtlib.c'" '(13608 characters)'
  213. if test -f 'rmtlib.c'
  214. then
  215.     echo shar: over-writing existing file "'rmtlib.c'"
  216. fi
  217. cat << \SHAR_EOF > 'rmtlib.c'
  218. /*
  219.  *    rmt --- remote tape emulator subroutines
  220.  *
  221.  *    Originally written by Jeff Lee, modified some by Arnold Robbins
  222.  *
  223.  *    WARNING:  The man page rmt(8) for /etc/rmt documents the remote mag
  224.  *    tape protocol which rdump and rrestore use.  Unfortunately, the man
  225.  *    page is *WRONG*.  The author of the routines I'm including originally
  226.  *    wrote his code just based on the man page, and it didn't work, so he
  227.  *    went to the rdump source to figure out why.  The only thing he had to
  228.  *    change was to check for the 'F' return code in addition to the 'E',
  229.  *    and to separate the various arguments with \n instead of a space.  I
  230.  *    personally don't think that this is much of a problem, but I wanted to
  231.  *    point it out.
  232.  *    -- Arnold Robbins
  233.  *
  234.  *    Redone as a library that can replace open, read, write, etc, by
  235.  *    Fred Fish, with some additional work by Arnold Robbins.
  236.  */
  237.  
  238. /*
  239.  *    MAXUNIT --- Maximum number of remote tape file units
  240.  *
  241.  *    READ --- Return the number of the read side file descriptor
  242.  *    WRITE --- Return the number of the write side file descriptor
  243.  */
  244.  
  245. #define RMTIOCTL    1
  246.  
  247. #include <stdio.h>
  248. #include <signal.h>
  249. #include <sys/types.h>
  250.  
  251. #ifdef RMTIOCTL
  252. #include <sys/ioctl.h>
  253. #include <sys/mtio.h>
  254. #endif
  255.  
  256. #include <errno.h>
  257. #include <setjmp.h>
  258. #include <sys/stat.h>
  259.  
  260. #define BUFMAGIC    64    /* a magic number for buffer sizes */
  261. #define MAXUNIT    4
  262.  
  263. #define READ(fd)    (Ctp[fd][0])
  264. #define WRITE(fd)    (Ptc[fd][1])
  265.  
  266. static int Ctp[MAXUNIT][2] = { -1, -1, -1, -1, -1, -1, -1, -1 };
  267. static int Ptc[MAXUNIT][2] = { -1, -1, -1, -1, -1, -1, -1, -1 };
  268.  
  269. static jmp_buf Jmpbuf;
  270. extern int errno;
  271.  
  272. /*
  273.  *    abort --- close off a remote tape connection
  274.  */
  275.  
  276. static void abort(fildes)
  277. int fildes;
  278. {
  279.     close(READ(fildes));
  280.     close(WRITE(fildes));
  281.     READ(fildes) = -1;
  282.     WRITE(fildes) = -1;
  283. }
  284.  
  285.  
  286.  
  287. /*
  288.  *    command --- attempt to perform a remote tape command
  289.  */
  290.  
  291. static int command(fildes, buf)
  292. int fildes;
  293. char *buf;
  294. {
  295.     register int blen;
  296.     int (*pstat)();
  297.  
  298. /*
  299.  *    save current pipe status and try to make the request
  300.  */
  301.  
  302.     blen = strlen(buf);
  303.     pstat = signal(SIGPIPE, SIG_IGN);
  304.     if (write(WRITE(fildes), buf, blen) == blen)
  305.     {
  306.         signal(SIGPIPE, pstat);
  307.         return(0);
  308.     }
  309.  
  310. /*
  311.  *    something went wrong. close down and go home
  312.  */
  313.  
  314.     signal(SIGPIPE, pstat);
  315.     abort(fildes);
  316.  
  317.     errno = EIO;
  318.     return(-1);
  319. }
  320.  
  321.  
  322.  
  323. /*
  324.  *    status --- retrieve the status from the pipe
  325.  */
  326.  
  327. static int status(fildes)
  328. int fildes;
  329. {
  330.     int i;
  331.     char c, *cp;
  332.     char buffer[BUFMAGIC];
  333.  
  334. /*
  335.  *    read the reply command line
  336.  */
  337.  
  338.     for (i = 0, cp = buffer; i < BUFMAGIC; i++, cp++)
  339.     {
  340.         if (read(READ(fildes), cp, 1) != 1)
  341.         {
  342.             abort(fildes);
  343.             errno = EIO;
  344.             return(-1);
  345.         }
  346.         if (*cp == '\n')
  347.         {
  348.             *cp = 0;
  349.             break;
  350.         }
  351.     }
  352.  
  353.     if (i == BUFMAGIC)
  354.     {
  355.         abort(fildes);
  356.         errno = EIO;
  357.         return(-1);
  358.     }
  359.  
  360. /*
  361.  *    check the return status
  362.  */
  363.  
  364.     for (cp = buffer; *cp; cp++)
  365.         if (*cp != ' ')
  366.             break;
  367.  
  368.     if (*cp == 'E' || *cp == 'F')
  369.     {
  370.         errno = atoi(cp + 1);
  371.         while (read(READ(fildes), &c, 1) == 1)
  372.             if (c == '\n')
  373.                 break;
  374.  
  375.         if (*cp == 'F')
  376.             abort(fildes);
  377.  
  378.         return(-1);
  379.     }
  380.  
  381. /*
  382.  *    check for mis-synced pipes
  383.  */
  384.  
  385.     if (*cp != 'A')
  386.     {
  387.         abort(fildes);
  388.         errno = EIO;
  389.         return(-1);
  390.     }
  391.  
  392.     return(atoi(cp + 1));
  393. }
  394.  
  395.  
  396.  
  397. /*
  398.  *    _rmt_open --- open a magtape device on system specified, as given user
  399.  *
  400.  *    file name has the form system[.user]:/dev/????
  401.  */
  402.  
  403. #define MAXHOSTLEN    257    /* BSD allows very long host names... */
  404.  
  405. static int _rmt_open (path, oflag, mode)
  406. char *path;
  407. int oflag;
  408. int mode;
  409. {
  410.     int i, rc;
  411.     char buffer[BUFMAGIC];
  412.     char system[MAXHOSTLEN];
  413.     char device[BUFMAGIC];
  414.     char login[BUFMAGIC];
  415.     char *sys, *dev, *user;
  416.  
  417.     sys = system;
  418.     dev = device;
  419.     user = login;
  420.  
  421. /*
  422.  *    first, find an open pair of file descriptors
  423.  */
  424.  
  425.     for (i = 0; i < MAXUNIT; i++)
  426.         if (READ(i) == -1 && WRITE(i) == -1)
  427.             break;
  428.  
  429.     if (i == MAXUNIT)
  430.     {
  431.         errno = EMFILE;
  432.         return(-1);
  433.     }
  434.  
  435. /*
  436.  *    pull apart system and device, and optional user
  437.  *    don't munge original string
  438.  */
  439.     while (*path != '.' && *path != ':') {
  440.         *sys++ = *path++;
  441.     }
  442.     *sys = '\0';
  443.     path++;
  444.  
  445.     if (*(path - 1) == '.')
  446.     {
  447.         while (*path != ':') {
  448.             *user++ = *path++;
  449.         }
  450.         *user = '\0';
  451.         path++;
  452.     }
  453.     else
  454.         *user = '\0';
  455.  
  456.     while (*path) {
  457.         *dev++ = *path++;
  458.     }
  459.     *dev = '\0';
  460.  
  461. /*
  462.  *    setup the pipes for the 'rsh' command and fork
  463.  */
  464.  
  465.     if (pipe(Ptc[i]) == -1 || pipe(Ctp[i]) == -1)
  466.         return(-1);
  467.  
  468.     if ((rc = fork()) == -1)
  469.         return(-1);
  470.  
  471.     if (rc == 0)
  472.     {
  473.         close(0);
  474.         dup(Ptc[i][0]);
  475.         close(Ptc[i][0]); close(Ptc[i][1]);
  476.         close(1);
  477.         dup(Ctp[i][1]);
  478.         close(Ctp[i][0]); close(Ctp[i][1]);
  479.         (void) setuid (getuid ());
  480.         (void) setgid (getgid ());
  481.         if (*user)
  482.         {
  483.             execl("/usr/ucb/rsh", "rsh", system, "-l", login,
  484.                 "/etc/rmt", (char *) 0);
  485.             execl("/usr/bin/remsh", "remsh", system, "-l", login,
  486.                 "/etc/rmt", (char *) 0);
  487.         }
  488.         else
  489.         {
  490.             execl("/usr/ucb/rsh", "rsh", system,
  491.                 "/etc/rmt", (char *) 0);
  492.             execl("/usr/bin/remsh", "remsh", system,
  493.                 "/etc/rmt", (char *) 0);
  494.         }
  495.  
  496. /*
  497.  *    bad problems if we get here
  498.  */
  499.  
  500.         perror("exec");
  501.         exit(1);
  502.     }
  503.  
  504.     close(Ptc[i][0]); close(Ctp[i][1]);
  505.  
  506. /*
  507.  *    now attempt to open the tape device
  508.  */
  509.  
  510.     sprintf(buffer, "O%s\n%d\n", device, oflag);
  511.     if (command(i, buffer) == -1 || status(i) == -1)
  512.         return(-1);
  513.  
  514.     return(i);
  515. }
  516.  
  517.  
  518.  
  519. /*
  520.  *    _rmt_close --- close a remote magtape unit and shut down
  521.  */
  522.  
  523. static int _rmt_close(fildes)
  524. int fildes;
  525. {
  526.     int rc;
  527.  
  528.     if (command(fildes, "C\n") != -1)
  529.     {
  530.         rc = status(fildes);
  531.  
  532.         abort(fildes);
  533.         return(rc);
  534.     }
  535.  
  536.     return(-1);
  537. }
  538.  
  539.  
  540.  
  541. /*
  542.  *    _rmt_read --- read a buffer from a remote tape
  543.  */
  544.  
  545. static int _rmt_read(fildes, buf, nbyte)
  546. int fildes;
  547. char *buf;
  548. unsigned int nbyte;
  549. {
  550.     int rc, i;
  551.     char buffer[BUFMAGIC];
  552.  
  553.     sprintf(buffer, "R%d\n", nbyte);
  554.     if (command(fildes, buffer) == -1 || (rc = status(fildes)) == -1)
  555.         return(-1);
  556.  
  557.     for (i = 0; i < rc; i += nbyte, buf += nbyte)
  558.     {
  559.         nbyte = read(READ(fildes), buf, rc);
  560.         if (nbyte <= 0)
  561.         {
  562.             abort(fildes);
  563.             errno = EIO;
  564.             return(-1);
  565.         }
  566.     }
  567.  
  568.     return(rc);
  569. }
  570.  
  571.  
  572.  
  573. /*
  574.  *    _rmt_write --- write a buffer to the remote tape
  575.  */
  576.  
  577. static int _rmt_write(fildes, buf, nbyte)
  578. int fildes;
  579. char *buf;
  580. unsigned int nbyte;
  581. {
  582.     int rc;
  583.     char buffer[BUFMAGIC];
  584.     int (*pstat)();
  585.  
  586.     sprintf(buffer, "W%d\n", nbyte);
  587.     if (command(fildes, buffer) == -1)
  588.         return(-1);
  589.  
  590.     pstat = signal(SIGPIPE, SIG_IGN);
  591.     if (write(WRITE(fildes), buf, nbyte) == nbyte)
  592.     {
  593.         signal (SIGPIPE, pstat);
  594.         return(status(fildes));
  595.     }
  596.  
  597.     signal (SIGPIPE, pstat);
  598.     abort(fildes);
  599.     errno = EIO;
  600.     return(-1);
  601. }
  602.  
  603.  
  604.  
  605. /*
  606.  *    _rmt_lseek --- perform an imitation lseek operation remotely
  607.  */
  608.  
  609. static long _rmt_lseek(fildes, offset, whence)
  610. int fildes;
  611. long offset;
  612. int whence;
  613. {
  614.     char buffer[BUFMAGIC];
  615.  
  616.     sprintf(buffer, "L%d\n%d\n", offset, whence);
  617.     if (command(fildes, buffer) == -1)
  618.         return(-1);
  619.  
  620.     return(status(fildes));
  621. }
  622.  
  623.  
  624. #ifdef RMTIOCTL
  625. /*
  626.  *    _rmt_ioctl --- perform raw tape operations remotely
  627.  */
  628.  
  629. static _rmt_ioctl(fildes, op, arg)
  630. int fildes, op;
  631. char *arg;
  632. {
  633.     char c;
  634.     int rc, cnt;
  635.     char buffer[BUFMAGIC];
  636.  
  637. /*
  638.  *    MTIOCOP is the easy one. nothing is transfered in binary
  639.  */
  640.  
  641.     if (op == MTIOCTOP)
  642.     {
  643.         sprintf(buffer, "I%d\n%d\n", ((struct mtop *) arg)->mt_op,
  644.             ((struct mtop *) arg)->mt_count);
  645.         if (command(fildes, buffer) == -1)
  646.             return(-1);
  647.         return(status(fildes));
  648.     }
  649.  
  650. /*
  651.  *    we can only handle 2 ops, if not the other one, punt
  652.  */
  653.  
  654.     if (op != MTIOCGET)
  655.     {
  656.         errno = EINVAL;
  657.         return(-1);
  658.     }
  659.  
  660. /*
  661.  *    grab the status and read it directly into the structure
  662.  *    this assumes that the status buffer is (hopefully) not
  663.  *    padded and that 2 shorts fit in a long without any word
  664.  *    alignment problems, ie - the whole struct is contiguous
  665.  *    NOTE - this is probably NOT a good assumption.
  666.  */
  667.  
  668.     if (command(fildes, "S\n") == -1 || (rc = status(fildes)) == -1)
  669.         return(-1);
  670.  
  671.     for (; rc > 0; rc -= cnt, arg += cnt)
  672.     {
  673.         cnt = read(READ(fildes), arg, rc);
  674.         if (cnt <= 0)
  675.         {
  676.             abort(fildes);
  677.             errno = EIO;
  678.             return(-1);
  679.         }
  680.     }
  681.  
  682. /*
  683.  *    now we check for byte position. mt_type is a small integer field
  684.  *    (normally) so we will check its magnitude. if it is larger than
  685.  *    256, we will assume that the bytes are swapped and go through
  686.  *    and reverse all the bytes
  687.  */
  688.  
  689.     if (((struct mtget *) arg)->mt_type < 256)
  690.         return(0);
  691.  
  692.     for (cnt = 0; cnt < rc; cnt += 2)
  693.     {
  694.         c = arg[cnt];
  695.         arg[cnt] = arg[cnt+1];
  696.         arg[cnt+1] = c;
  697.     }
  698.  
  699.     return(0);
  700.   }
  701. #endif /* RMTIOCTL */
  702.  
  703. /*
  704.  *    Added routines to replace open(), close(), lseek(), ioctl(), etc.
  705.  *    The preprocessor can be used to remap these the rmtopen(), etc
  706.  *    thus minimizing source changes:
  707.  *
  708.  *        #ifdef REMOTETAPE
  709.  *        #  define access rmtaccess
  710.  *        #  define close rmtclose
  711.  *        #  define creat rmtcreat
  712.  *        #  define dup rmtdup
  713.  *        #  define fcntl rmtfcntl
  714.  *        #  define fstat rmtfstat
  715.  *        #  define ioctl rmtioctl
  716.  *        #  define isatty rmtisatty
  717.  *        #  define lseek rmtlseek
  718.  *        #  define lstat rmtlstat
  719.  *        #  define open rmtopen
  720.  *        #  define read rmtread
  721.  *        #  define stat rmtstat
  722.  *        #  define write rmtwrite
  723.  *        #  define access rmtaccess
  724.  *        #  define close rmtclose
  725.  *        #  define creat rmtcreat
  726.  *        #  define dup rmtdup
  727.  *        #  define fcntl rmtfcntl
  728.  *        #  define fstat rmtfstat
  729.  *        #  define ioctl rmtioctl
  730.  *        #  define lseek rmtlseek
  731.  *        #  define open rmtopen
  732.  *        #  define read rmtread
  733.  *        #  define stat rmtstat
  734.  *        #  define write rmtwrite
  735.  *        #endif
  736.  *
  737.  *    -- Fred Fish
  738.  *
  739.  *    ADR --- I set up a <rmt.h> include file for this
  740.  *
  741.  */
  742.  
  743. /*
  744.  *    Note that local vs remote file descriptors are distinquished
  745.  *    by adding a bias to the remote descriptors.  This is a quick
  746.  *    and dirty trick that may not be portable to some systems.
  747.  */
  748.  
  749. #define REM_BIAS 128
  750.  
  751.  
  752. /*
  753.  *    Test pathname to see if it is local or remote.  A remote device
  754.  *    is any string that contains ":/dev/".  Returns 1 if remote,
  755.  *    0 otherwise.
  756.  */
  757.  
  758. static int remdev (path)
  759. register char *path;
  760. {
  761. #define strchr    index
  762.     extern char *strchr ();
  763.  
  764.     if ((path = strchr (path, ':')) != NULL)
  765.     {
  766.         if (strncmp (path + 1, "/dev/", 5) == 0)
  767.         {
  768.             return (1);
  769.         }
  770.     }
  771.     return (0);
  772. }
  773.  
  774.  
  775. /*
  776.  *    Open a local or remote file.  Looks just like open(2) to
  777.  *    caller.
  778.  */
  779.  
  780. int rmtopen (path, oflag, mode)
  781. char *path;
  782. int oflag;
  783. int mode;
  784. {
  785.     if (remdev (path))
  786.     {
  787.         return (_rmt_open (path, oflag, mode) + REM_BIAS);
  788.     }
  789.     else
  790.     {
  791.         return (open (path, oflag, mode));
  792.     }
  793. }
  794.  
  795. /*
  796.  *    Test pathname for specified access.  Looks just like access(2)
  797.  *    to caller.
  798.  */
  799.  
  800. int rmtaccess (path, amode)
  801. char *path;
  802. int amode;
  803. {
  804.     if (remdev (path))
  805.     {
  806.         return (0);        /* Let /etc/rmt find out */
  807.     }
  808.     else
  809.     {
  810.         return (access (path, amode));
  811.     }
  812. }
  813.  
  814.  
  815. /*
  816.  *    Read from stream.  Looks just like read(2) to caller.
  817.  */
  818.   
  819. int rmtread (fildes, buf, nbyte)
  820. int fildes;
  821. char *buf;
  822. unsigned int nbyte;
  823. {
  824.     if (isrmt (fildes))
  825.     {
  826.         return (_rmt_read (fildes - REM_BIAS, buf, nbyte));
  827.     }
  828.     else
  829.     {
  830.         return (read (fildes, buf, nbyte));
  831.     }
  832. }
  833.  
  834.  
  835. /*
  836.  *    Write to stream.  Looks just like write(2) to caller.
  837.  */
  838.  
  839. int rmtwrite (fildes, buf, nbyte)
  840. int fildes;
  841. char *buf;
  842. unsigned int nbyte;
  843. {
  844.     if (isrmt (fildes))
  845.     {
  846.         return (_rmt_write (fildes - REM_BIAS, buf, nbyte));
  847.     }
  848.     else
  849.     {
  850.         return (write (fildes, buf, nbyte));
  851.     }
  852. }
  853.  
  854. /*
  855.  *    Perform lseek on file.  Looks just like lseek(2) to caller.
  856.  */
  857.  
  858. long rmtlseek (fildes, offset, whence)
  859. int fildes;
  860. long offset;
  861. int whence;
  862. {
  863.     if (isrmt (fildes))
  864.     {
  865.         return (_rmt_lseek (fildes - REM_BIAS, offset, whence));
  866.     }
  867.     else
  868.     {
  869.         return (lseek (fildes, offset, whence));
  870.     }
  871. }
  872.  
  873.  
  874. /*
  875.  *    Close a file.  Looks just like close(2) to caller.
  876.  */
  877.  
  878. int rmtclose (fildes)
  879. int fildes;
  880. {
  881.     if (isrmt (fildes))
  882.     {
  883.         return (_rmt_close (fildes - REM_BIAS));
  884.     }
  885.     else
  886.     {
  887.         return (close (fildes));
  888.     }
  889. }
  890.  
  891. /*
  892.  *    Do ioctl on file.  Looks just like ioctl(2) to caller.
  893.  */
  894.  
  895. int rmtioctl (fildes, request, arg)
  896. int fildes, request, arg;
  897. {
  898.     if (isrmt (fildes))
  899.     {
  900.         errno = EOPNOTSUPP;
  901.         return (-1);        /* For now  (fnf) */
  902.     }
  903.     else
  904.     {
  905.         return (ioctl (fildes, request, arg));
  906.     }
  907. }
  908.  
  909.  
  910. /*
  911.  *    Duplicate an open file descriptor.  Looks just like dup(2)
  912.  *    to caller.
  913.  */
  914.  
  915. int rmtdup (fildes)
  916. int fildes;
  917. {
  918.     if (isrmt (fildes))
  919.     {
  920.         errno = EOPNOTSUPP;
  921.         return (-1);        /* For now (fnf) */
  922.     }
  923.     else
  924.     {
  925.         return (dup (fildes));
  926.     }
  927. }
  928.  
  929. /*
  930.  *    Get file status.  Looks just like fstat(2) to caller.
  931.  */
  932.  
  933. int rmtfstat (fildes, buf)
  934. int fildes;
  935. struct stat *buf;
  936. {
  937.     if (isrmt (fildes))
  938.     {
  939.         errno = EOPNOTSUPP;
  940.         return (-1);        /* For now (fnf) */
  941.     }
  942.     else
  943.     {
  944.         return (fstat (fildes, buf));
  945.     }
  946. }
  947.  
  948.  
  949. /*
  950.  *    Get file status.  Looks just like stat(2) to caller.
  951.  */
  952.  
  953. int rmtstat (path, buf)
  954. char *path;
  955. struct stat *buf;
  956. {
  957.     if (remdev (path))
  958.     {
  959.         errno = EOPNOTSUPP;
  960.         return (-1);        /* For now (fnf) */
  961.     }
  962.     else
  963.     {
  964.         return (stat (path, buf));
  965.     }
  966. }
  967.  
  968.  
  969.  
  970. /*
  971.  *    Create a file from scratch.  Looks just like creat(2) to the caller.
  972.  */
  973.  
  974. #include <sys/file.h>        /* BSD DEPENDANT!!! */
  975. /* #include <fcntl.h>        /* use this one for S5 with remote stuff */
  976.  
  977. int rmtcreat (path, mode)
  978. char *path;
  979. int mode;
  980. {
  981.     if (remdev (path))
  982.     {
  983.         return (rmtopen (path, 1 | O_CREAT, mode));
  984.     }
  985.     else
  986.     {
  987.         return (creat (path, mode));
  988.     }
  989. }
  990.  
  991. /*
  992.  *    Isrmt. Let a programmer know he has a remote device.
  993.  */
  994.  
  995. int isrmt (fd)
  996. int fd;
  997. {
  998.     return (fd >= REM_BIAS);
  999. }
  1000.  
  1001. /*
  1002.  *    Rmtfcntl. Do a remote fcntl operation.
  1003.  */
  1004.  
  1005. int rmtfcntl (fd, cmd, arg)
  1006. int fd, cmd, arg;
  1007. {
  1008.     if (isrmt (fd))
  1009.     {
  1010.         errno = EOPNOTSUPP;
  1011.         return (-1);
  1012.     }
  1013.     else
  1014.     {
  1015.         return (fcntl (fd, cmd, arg));
  1016.     }
  1017. }
  1018.  
  1019. /*
  1020.  *    Rmtisatty.  Do the isatty function.
  1021.  */
  1022.  
  1023. int rmtisatty (fd)
  1024. int fd;
  1025. {
  1026.     if (isrmt (fd))
  1027.         return (0);
  1028.     else
  1029.         return (isatty (fd));
  1030. }
  1031.  
  1032.  
  1033. /*
  1034.  *    Get file status, even if symlink.  Looks just like lstat(2) to caller.
  1035.  */
  1036.  
  1037. int rmtlstat (path, buf)
  1038. char *path;
  1039. struct stat *buf;
  1040. {
  1041.     if (remdev (path))
  1042.     {
  1043.         errno = EOPNOTSUPP;
  1044.         return (-1);        /* For now (fnf) */
  1045.     }
  1046.     else
  1047.     {
  1048.         return (lstat (path, buf));
  1049.     }
  1050. }
  1051. SHAR_EOF
  1052. echo shar: extracting "'rmtops.3'" '(4071 characters)'
  1053. if test -f 'rmtops.3'
  1054. then
  1055.     echo shar: over-writing existing file "'rmtops.3'"
  1056. fi
  1057. cat << \SHAR_EOF > 'rmtops.3'
  1058. .TH RMTOPS 3 local
  1059. .SH NAME
  1060. rmtops \- access tape drives on remote machines
  1061. .SH SYNOPSIS
  1062. .nf
  1063. #include <rmt.h>
  1064. #include <sys/stat.h>    /* MUST come after <rmt.h> */
  1065.  
  1066. int isrmt (fd)
  1067. int fd;
  1068.  
  1069. int rmtaccess (file, mode)
  1070. char *file;
  1071. int mode;
  1072.  
  1073. int rmtclose (fd)
  1074. int fd;
  1075.  
  1076. int rmtcreat (file, mode)
  1077. char *file;
  1078. int mode;
  1079.  
  1080. int rmtdup (fd)
  1081. int fd;
  1082.  
  1083. int rmtfcntl (fd, cmd, arg)
  1084. int fd, cmd, arg;
  1085.  
  1086. int rmtfstat (fd, buf)
  1087. int fd;
  1088. struct stat *buf;
  1089.  
  1090. int rmtioctl (fd, request, argp)
  1091. int fd, request;
  1092. char *argp;
  1093.  
  1094. int rmtisatty (fd)
  1095. int fd;
  1096.  
  1097. long rmtlseek (fd, offset, whence)
  1098. int fd, whence;
  1099. long offset;
  1100.  
  1101. int rmtlstat (file, buf)
  1102. char *file;
  1103. struct stat *buf;
  1104.  
  1105. int rmtopen (file, flags [, mode])
  1106. char *file;
  1107. int flags, mode;
  1108.  
  1109. int rmtread (fd, buf, nbytes)
  1110. int fd, nbytes;
  1111. char *buf;
  1112.  
  1113. int rmtstat (file, buf)
  1114. char *file;
  1115. struct stat *buf;
  1116.  
  1117. int rmtwrite (fd, buf, nbytes)
  1118. int fd, nbytes;
  1119. char *buf;
  1120. .fi
  1121. .SH DESCRIPTION
  1122. .I Rmtops
  1123. provides a simple means of transparently accessing tape drives
  1124. on remote machines over the ethernet, via
  1125. .IR rsh (1)
  1126. and
  1127. .IR rmt (8).
  1128. These routines are used like their corresponding
  1129. system calls, but allow the user to open up a tape drive on a remote
  1130. system on which he or she has an account and the appropriate remote
  1131. permissions.
  1132. .PP
  1133. A remote tape drive file name has the form
  1134. .sp
  1135. .RS
  1136. .IR system [. user ]:/dev/???
  1137. .RE
  1138. .sp
  1139. where
  1140. .I system
  1141. is the remote system,
  1142. .I /dev/???
  1143. is the particular drive on the remote system (raw, blocked, rewinding,
  1144. non-rewinding, etc.), and the optional
  1145. .I user
  1146. is the login name to be used on the remote system, if different from
  1147. the current user's login name.
  1148. This corresponds to the remote syntax used by
  1149. .IR rcp (1).
  1150. .PP
  1151. For transparency, the user should include the file
  1152. .IR <rmt.h> ,
  1153. which has the following defines in it:
  1154. .PP
  1155. .nf
  1156. #define access rmtaccess
  1157. #define close rmtclose
  1158. #define creat rmtcreat
  1159. #define dup rmtdup
  1160. #define fcntl rmtfcntl
  1161. #define fstat rmtfstat
  1162. #define ioctl rmtioctl
  1163. #define isatty rmtisatty
  1164. #define lseek rmtlseek
  1165. #define lstat rmtlstat
  1166. #define open rmtopen
  1167. #define read rmtread
  1168. #define stat rmtstat
  1169. #define write rmtwrite
  1170. .fi
  1171. .PP
  1172. This allows the programmer to use
  1173. .IR open ,
  1174. .IR close ,
  1175. .IR read ,
  1176. .IR write ,
  1177. etc. in their normal fashion, with the
  1178. .I rmtops
  1179. routines taking care of differentiating between local and remote files.
  1180. This file should be included
  1181. .I before
  1182. including the file
  1183. .IR <sys/stat.h> ,
  1184. since it redefines the identifier ``stat,'' which is used to declare
  1185. objects of type struct stat.
  1186. .PP
  1187. The routines differentiate between local and remote file descriptors by
  1188. adding a bias (currently 128) to the file descriptor of the pipe.
  1189. The programmer, if he must know if a file is remote, should use the
  1190. .I isrmt
  1191. function.
  1192. .SH FILES
  1193. .TP
  1194. .B /usr/lib/librmt.a
  1195. Contains the remote tape library.  To include the library with a program,
  1196. add the flag
  1197. .I -lrmt
  1198. to the
  1199. .IR cc (1)
  1200. command line.
  1201. .SH SEE ALSO
  1202. .IR rcp (1),
  1203. .IR rsh (1),
  1204. .IR rmt (8),
  1205. and the appropriate system calls in section 2.
  1206. .SH DIAGNOSTICS
  1207. Several of these routines will return -1 and set
  1208. .I errno
  1209. to EOPNOTSUPP, if they are given a remote file name or a file descriptor
  1210. on an open remote file (e.g.,
  1211. .IR rmtdup ).
  1212. .SH BUGS
  1213. See diagnostics above.  It is to be hoped that true remote file systems
  1214. will eventually appear, and eliminate the need for these routines.
  1215. .PP
  1216. There is no way to use remote tape drives with the
  1217. .IR stdio (3)
  1218. package, short of recompiling it entirely to use these routines.
  1219. .PP
  1220. The
  1221. .IR rmt (8)
  1222. protocol is not very capable.  In particular, it relies on
  1223. TCP/IP sockets for error free transmission, and does no data validation
  1224. of its own.
  1225. .PP
  1226. The
  1227. .I rmt
  1228. program allows no more than 10K bytes to be transferred at one time.
  1229. Anymore is truncated.
  1230. .SH AUTHORS
  1231. Jeff Lee (gatech!jeff) wrote the original routines for accessing
  1232. tape drives via
  1233. .IR rmt (8).
  1234. .PP
  1235. Fred Fish (unisoft!fnf) redid them into a general purpose library.
  1236. .PP
  1237. Arnold Robbins (gatech!arnold) added the ability to specify a user
  1238. name on the remote system, the
  1239. .I <rmt.h>
  1240. include file, this man page,
  1241. and cleaned up the library a little.
  1242. SHAR_EOF
  1243. echo shar: extracting "'tar.1.DIFF'" '(1910 characters)'
  1244. if test -f 'tar.1.DIFF'
  1245. then
  1246.     echo shar: over-writing existing file "'tar.1.DIFF'"
  1247. fi
  1248. cat << \SHAR_EOF > 'tar.1.DIFF'
  1249. *** /usr/man/man1/oldtar.1    Mon Jun 27 00:35:14 1983
  1250. --- tar.1    Wed Jul 24 12:28:29 1985
  1251. ***************
  1252. *** 78,84
  1253.   .I tar
  1254.   does its work silently.  The
  1255.   .B v
  1256. ! (verbose) option make
  1257.   .I tar
  1258.   type the name of each file it treats preceded by the function
  1259.   letter.  With the
  1260.  
  1261. --- 78,84 -----
  1262.   .I tar
  1263.   does its work silently.  The
  1264.   .B v
  1265. ! (verbose) option makes
  1266.   .I tar
  1267.   type the name of each file it treats preceded by the function
  1268.   letter.  With the
  1269. ***************
  1270. *** 95,101
  1271.   .B f
  1272.   .I Tar
  1273.   uses the next argument as the name of the archive instead of
  1274. ! /dev/rmt?. If the name of the file is `\-', tar writes to standard output or
  1275.   reads from standard input, whichever is appropriate. Thus,
  1276.   .I tar
  1277.   can be used as the head or tail of a filter chain.
  1278.  
  1279. --- 95,120 -----
  1280.   .B f
  1281.   .I Tar
  1282.   uses the next argument as the name of the archive instead of
  1283. ! /dev/rmt?.
  1284. ! .sp
  1285. ! If the file name has the form
  1286. ! .IR system [. user ]:/dev/???
  1287. ! .I tar
  1288. ! will use the tape drive /dev/??? on the remote system
  1289. ! .IR system ,
  1290. ! via
  1291. ! .IR rsh (1),
  1292. ! and
  1293. ! .IR rmt (8).
  1294. ! The optional
  1295. ! .I user
  1296. ! portion of the pathname specifies the login name to use on the
  1297. ! remote system.
  1298. ! If it is not supplied, the current user's login name will be used.
  1299. ! In all the cases, the user must have the appropriate
  1300. ! permissions on the remote machine, in order to use this facility.
  1301. ! .sp
  1302. ! If the name of the file is `\-', tar writes to standard output or
  1303.   reads from standard input, whichever is appropriate. Thus,
  1304.   .I tar
  1305.   can be used as the head or tail of a filter chain.
  1306. ***************
  1307. *** 179,181
  1308.   The current limit on file name length is 100 characters.
  1309.   .br
  1310.   There is no way to selectively follow symbolic links.
  1311.  
  1312. --- 198,202 -----
  1313.   The current limit on file name length is 100 characters.
  1314.   .br
  1315.   There is no way to selectively follow symbolic links.
  1316. + .br
  1317. + Using a remote system's tape drive can be slow.
  1318. SHAR_EOF
  1319. echo shar: extracting "'tar.c.DIFF'" '(2026 characters)'
  1320. if test -f 'tar.c.DIFF'
  1321. then
  1322.     echo shar: over-writing existing file "'tar.c.DIFF'"
  1323. fi
  1324. cat << \SHAR_EOF > 'tar.c.DIFF'
  1325. *** /usr/src/bin/tar.c    Wed Nov 14 00:09:23 1984
  1326. --- tar.c    Wed Jul 24 12:26:38 1985
  1327. ***************
  1328. *** 27,32
  1329.    * Tape Archival Program
  1330.    */
  1331.   #include <stdio.h>
  1332.   #include <sys/param.h>
  1333.   #include <sys/stat.h>
  1334.   #include <sys/dir.h>
  1335.  
  1336. --- 27,33 -----
  1337.    * Tape Archival Program
  1338.    */
  1339.   #include <stdio.h>
  1340. + #include <rmt.h>    /* remote tape, must come before <sys/stat.h> */
  1341.   #include <sys/param.h>
  1342.   #include <sys/stat.h>
  1343.   #include <sys/dir.h>
  1344. ***************
  1345. *** 306,311
  1346.           doxtract(argv);
  1347.       else
  1348.           dotable();
  1349.       done(0);
  1350.   }
  1351.   
  1352.  
  1353. --- 307,313 -----
  1354.           doxtract(argv);
  1355.       else
  1356.           dotable();
  1357. +     close (mt);
  1358.       done(0);
  1359.   }
  1360.   
  1361. ***************
  1362. *** 722,728
  1363.           if (checkdir(dblock.dbuf.name))
  1364.               continue;
  1365.           if (dblock.dbuf.linkflag == '2') {
  1366. !             unlink(dblock.dbuf.name);
  1367.               if (symlink(dblock.dbuf.linkname, dblock.dbuf.name)<0) {
  1368.                   fprintf(stderr, "tar: %s: symbolic link failed\n",
  1369.                       dblock.dbuf.name);
  1370.  
  1371. --- 724,736 -----
  1372.           if (checkdir(dblock.dbuf.name))
  1373.               continue;
  1374.           if (dblock.dbuf.linkflag == '2') {
  1375. !             /*
  1376. !              * only unlink non-directories or empty directories
  1377. !              */
  1378. !             if (rmdir (dblock.dbuf.name) < 0) {
  1379. !                 if (errno == ENOTDIR)
  1380. !                     unlink(dblock.dbuf.name);
  1381. !             }
  1382.               if (symlink(dblock.dbuf.linkname, dblock.dbuf.name)<0) {
  1383.                   fprintf(stderr, "tar: %s: symbolic link failed\n",
  1384.                       dblock.dbuf.name);
  1385. ***************
  1386. *** 749,755
  1387.               continue;
  1388.           }
  1389.           if (dblock.dbuf.linkflag == '1') {
  1390. !             unlink(dblock.dbuf.name);
  1391.               if (link(dblock.dbuf.linkname, dblock.dbuf.name) < 0) {
  1392.                   fprintf(stderr, "tar: %s: cannot link\n",
  1393.                       dblock.dbuf.name);
  1394.  
  1395. --- 757,769 -----
  1396.               continue;
  1397.           }
  1398.           if (dblock.dbuf.linkflag == '1') {
  1399. !             /*
  1400. !              * only unlink non-directories or empty directories
  1401. !              */
  1402. !             if (rmdir (dblock.dbuf.name) < 0) {
  1403. !                 if (errno == ENOTDIR)
  1404. !                     unlink(dblock.dbuf.name);
  1405. !             }
  1406.               if (link(dblock.dbuf.linkname, dblock.dbuf.name) < 0) {
  1407.                   fprintf(stderr, "tar: %s: cannot link\n",
  1408.                       dblock.dbuf.name);
  1409. SHAR_EOF
  1410. #    End of shell archive
  1411. exit 0
  1412.  
  1413.